{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import random\n",
    "import time\n",
    "import collections\n",
    "from tqdm import tqdm\n",
    "sns.set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_dataset(words, n_words, atleast=1):\n",
    "    count = [['PAD', 0], ['GO', 1], ['EOS', 2], ['UNK', 3]]\n",
    "    counter = collections.Counter(words).most_common(n_words)\n",
    "    counter = [i for i in counter if i[1] >= atleast]\n",
    "    count.extend(counter)\n",
    "    dictionary = dict()\n",
    "    for word, _ in count:\n",
    "        dictionary[word] = len(dictionary)\n",
    "    data = list()\n",
    "    unk_count = 0\n",
    "    for word in words:\n",
    "        index = dictionary.get(word, 0)\n",
    "        if index == 0:\n",
    "            unk_count += 1\n",
    "        data.append(index)\n",
    "    count[0][1] = unk_count\n",
    "    reversed_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\n",
    "    return data, count, dictionary, reversed_dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('shakespeare.txt') as fopen:\n",
    "    shakespeare = fopen.read().split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocabulary_size = len(list(set(shakespeare)))\n",
    "data, count, dictionary, rev_dictionary = build_dataset(shakespeare, vocabulary_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "GO = dictionary['GO']\n",
    "PAD = dictionary['PAD']\n",
    "EOS = dictionary['EOS']\n",
    "UNK = dictionary['UNK']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Generator:\n",
    "    def __init__(self, size_layer, num_layers, embedded_size,\n",
    "                 from_dict_size, to_dict_size, learning_rate, batch_size):\n",
    "        \n",
    "        def cells(reuse=False):\n",
    "            return tf.nn.rnn_cell.GRUCell(size_layer,reuse=reuse)\n",
    "        \n",
    "        self.X = tf.placeholder(tf.int32, [None, None])\n",
    "        self.Y = tf.placeholder(tf.int32, [None, None])\n",
    "        self.X_seq_len = tf.count_nonzero(self.X, 1, dtype=tf.int32)\n",
    "        self.Y_seq_len = tf.count_nonzero(self.Y, 1, dtype=tf.int32)\n",
    "        batch_size = tf.shape(self.X)[0]\n",
    "        \n",
    "        encoder_embedding = tf.Variable(tf.random_uniform([from_dict_size, embedded_size], -1, 1))\n",
    "        decoder_embedding = tf.Variable(tf.random_uniform([to_dict_size, embedded_size], -1, 1))\n",
    "        self.cells = tf.nn.rnn_cell.MultiRNNCell([cells() for _ in range(num_layers)])\n",
    "        self.encoder_state = self.cells.zero_state(\n",
    "            dtype = tf.float32, batch_size = tf.shape(self.X)[0]\n",
    "        )\n",
    "        \n",
    "        encoder_out, encoder_state = tf.nn.dynamic_rnn(\n",
    "            cell = self.cells, \n",
    "            inputs = tf.nn.embedding_lookup(encoder_embedding, self.X),\n",
    "            sequence_length = self.X_seq_len,\n",
    "            initial_state = self.encoder_state,\n",
    "            dtype = tf.float32)\n",
    "        \n",
    "        main = tf.strided_slice(self.Y, [0, 0], [batch_size, -1], [1, 1])\n",
    "        decoder_input = tf.concat([tf.fill([batch_size, 1], GO), main], 1)\n",
    "        dense = tf.layers.Dense(to_dict_size)\n",
    "        attention_mechanism = tf.contrib.seq2seq.LuongAttention(num_units = size_layer, \n",
    "                                                                    memory = encoder_out,\n",
    "                                                                    memory_sequence_length = self.X_seq_len)\n",
    "        \n",
    "        decoder_cells = tf.contrib.seq2seq.AttentionWrapper(\n",
    "            cell = tf.nn.rnn_cell.MultiRNNCell([cells() for _ in range(num_layers)]), \n",
    "                attention_mechanism = attention_mechanism,\n",
    "                attention_layer_size = size_layer)\n",
    "        \n",
    "        training_helper = tf.contrib.seq2seq.TrainingHelper(\n",
    "                inputs = tf.nn.embedding_lookup(decoder_embedding, decoder_input),\n",
    "                sequence_length = self.Y_seq_len,\n",
    "                time_major = False)\n",
    "        training_decoder = tf.contrib.seq2seq.BasicDecoder(\n",
    "                cell = decoder_cells,\n",
    "                helper = training_helper,\n",
    "                initial_state = decoder_cells.zero_state(batch_size, tf.float32).clone(cell_state=encoder_state),\n",
    "                output_layer = dense)\n",
    "        training_decoder_output, self.training_state, _ = tf.contrib.seq2seq.dynamic_decode(\n",
    "                decoder = training_decoder,\n",
    "                impute_finished = True,\n",
    "                maximum_iterations = tf.reduce_max(self.Y_seq_len))\n",
    "        self.training_logits = training_decoder_output.rnn_output\n",
    "        \n",
    "        predicting_helper = tf.contrib.seq2seq.GreedyEmbeddingHelper(\n",
    "                embedding = decoder_embedding,\n",
    "                start_tokens = tf.tile(tf.constant([GO], dtype=tf.int32), [batch_size]),\n",
    "                end_token = EOS)\n",
    "        predicting_decoder = tf.contrib.seq2seq.BasicDecoder(\n",
    "                cell = decoder_cells,\n",
    "                helper = predicting_helper,\n",
    "                initial_state = decoder_cells.zero_state(batch_size, tf.float32).clone(cell_state=encoder_state),\n",
    "                output_layer = dense)\n",
    "        predicting_decoder_output, self.predict_state, _ = tf.contrib.seq2seq.dynamic_decode(\n",
    "                decoder = predicting_decoder,\n",
    "                impute_finished = True,\n",
    "                maximum_iterations = tf.reduce_max(self.X_seq_len))\n",
    "        self.predicting_ids = predicting_decoder_output.sample_id\n",
    "        print(self.training_state, self.predict_state)\n",
    "        \n",
    "        masks = tf.sequence_mask(self.Y_seq_len, tf.reduce_max(self.Y_seq_len), dtype=tf.float32)\n",
    "        self.cost = tf.contrib.seq2seq.sequence_loss(logits = self.training_logits,\n",
    "                                                     targets = self.Y,\n",
    "                                                     weights = masks)\n",
    "        self.optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(self.cost)\n",
    "        \n",
    "        y_t = tf.argmax(self.training_logits,axis=2)\n",
    "        y_t = tf.cast(y_t, tf.int32)\n",
    "        self.prediction = tf.boolean_mask(y_t, masks)\n",
    "        mask_label = tf.boolean_mask(self.Y, masks)\n",
    "        correct_pred = tf.equal(self.prediction, mask_label)\n",
    "        correct_index = tf.cast(correct_pred, tf.float32)\n",
    "        self.accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "learning_rate = 0.001\n",
    "batch_size = 32\n",
    "sequence_length = 64\n",
    "epoch = 3000\n",
    "num_layers = 2\n",
    "size_layer = 256\n",
    "possible_batch_id = range(len(data) - sequence_length - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AttentionWrapperState(cell_state=(<tf.Tensor 'decoder/while/Exit_4:0' shape=(?, 256) dtype=float32>, <tf.Tensor 'decoder/while/Exit_5:0' shape=(?, 256) dtype=float32>), attention=<tf.Tensor 'decoder/while/Exit_6:0' shape=(?, 256) dtype=float32>, time=<tf.Tensor 'decoder/while/Exit_7:0' shape=() dtype=int32>, alignments=<tf.Tensor 'decoder/while/Exit_8:0' shape=(?, ?) dtype=float32>, alignment_history=(), attention_state=<tf.Tensor 'decoder/while/Exit_9:0' shape=(?, ?) dtype=float32>) AttentionWrapperState(cell_state=(<tf.Tensor 'decoder_1/while/Exit_4:0' shape=(?, 256) dtype=float32>, <tf.Tensor 'decoder_1/while/Exit_5:0' shape=(?, 256) dtype=float32>), attention=<tf.Tensor 'decoder_1/while/Exit_6:0' shape=(?, 256) dtype=float32>, time=<tf.Tensor 'decoder_1/while/Exit_7:0' shape=() dtype=int32>, alignments=<tf.Tensor 'decoder_1/while/Exit_8:0' shape=(?, ?) dtype=float32>, alignment_history=(), attention_state=<tf.Tensor 'decoder_1/while/Exit_9:0' shape=(?, ?) dtype=float32>)\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "sess = tf.InteractiveSession()\n",
    "model = Generator(size_layer, num_layers, size_layer, len(dictionary), \n",
    "                len(dictionary), learning_rate,batch_size)\n",
    "sess.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_random_batch():\n",
    "    LOST, ACCURACY = [], []\n",
    "    pbar = tqdm(range(epoch), desc = 'epoch')\n",
    "    batch_id = random.sample(possible_batch_id, batch_size)\n",
    "    batch_x = np.zeros((batch_size, sequence_length))\n",
    "    batch_y = np.zeros((batch_size, sequence_length + 1))\n",
    "    for n in range(sequence_length):\n",
    "        id1 = [data[k + n] for k in batch_id]\n",
    "        id2 = [data[k + n + 1] for k in batch_id]\n",
    "        batch_x[:,n] = id1\n",
    "        batch_y[:,n] = id2\n",
    "    batch_y[:,-1] = [EOS] * batch_size\n",
    "    initial_state, _ = sess.run([model.predict_state, model.optimizer], feed_dict = {model.X: batch_x,\n",
    "                                                                                    model.Y: batch_y})\n",
    "    initial_state = initial_state.cell_state\n",
    "    \n",
    "    for i in pbar:\n",
    "        batch_x = np.zeros((batch_size, sequence_length))\n",
    "        batch_y = np.zeros((batch_size, sequence_length + 1))\n",
    "        batch_id = random.sample(possible_batch_id, batch_size)\n",
    "        for n in range(sequence_length):\n",
    "            id1 = [data[k + n] for k in batch_id]\n",
    "            id2 = [data[k + n + 1] for k in batch_id]\n",
    "            batch_x[:,n] = id1\n",
    "            batch_y[:,n] = id2\n",
    "        batch_y[:,-1] = [EOS] * batch_size\n",
    "        accuracy, _, loss, initial_state = sess.run([model.accuracy, model.optimizer, \n",
    "                                                     model.cost, model.predict_state], \n",
    "                                       feed_dict = {model.X: batch_x, \n",
    "                                                    model.Y: batch_y,\n",
    "                                                    model.encoder_state: initial_state})\n",
    "        initial_state = initial_state.cell_state\n",
    "        ACCURACY.append(accuracy); LOST.append(loss)\n",
    "        pbar.set_postfix(cost = loss, accuracy = accuracy)\n",
    "    return LOST, ACCURACY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "epoch: 100%|██████████| 3000/3000 [1:41:50<00:00,  1.03s/it, accuracy=0.0591, cost=6.7] \n"
     ]
    }
   ],
   "source": [
    "LOST, ACCURACY = train_random_batch()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (15, 5))\n",
    "plt.subplot(1, 2, 1)\n",
    "EPOCH = np.arange(len(LOST))\n",
    "plt.plot(EPOCH, LOST)\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('loss')\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(EPOCH, ACCURACY)\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_based_sequence(length_sentence):\n",
    "    index = np.random.randint(0, len(data) - sequence_length - 1)\n",
    "    x = np.array([data[index:index + sequence_length]])\n",
    "    initial_state, ids = sess.run([model.predict_state,model.predicting_ids], \n",
    "                                  feed_dict = {model.X: x})\n",
    "    initial_state = initial_state.cell_state\n",
    "    ids = ids[0].tolist()\n",
    "    \n",
    "    while len(ids) < length_sentence:\n",
    "        initial_state, ids_ = sess.run([model.predict_state,model.predicting_ids], \n",
    "                                      feed_dict = {model.X: [ids[-sequence_length:]],\n",
    "                                                  model.encoder_state: initial_state})\n",
    "        initial_state = initial_state.cell_state\n",
    "        ids.extend(ids_[0].tolist())\n",
    "\n",
    "    return ''.join([rev_dictionary[i] for i in ids])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "withaoldownaoldownMERCUTIO:andaoldownownownownownownownownownownownownownownownownownownownownownownMERCUTIO:andaEOSaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaalook,--doaalook,--doaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaalook,--doaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaalook,--doalook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--doalook,--dolook,--dolook,--doalook,--dolook,--doalook,--dolook,--doaalook,--dolook,--doaalook,--dolook,--doaalook,--dolook,--doaalook,--dolook,--doaalook,--dolook,--doaalook,--dolook,--doaalook,--dolook,--doaalook,--doaalook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--doVolsce:youmalignEOSyouyouyouyouyouyouyouyouyouyouyouyouEOSyouyouyouguess?guess?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?EOSIyouyouIhavenotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotEOSshallnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotEOSANNE:notnotnotnotnotnotnotnotnotnotnotEOSANNE:notnotnotnotnotnotnotnotnotnotEOSthousharp-pointedsharp-pointedsharp-pointedsharp-pointedsharp-pointedsharp-pointedsharp-pointedsharp-pointedEOScontempt.eyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballofthetheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseawiththethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethetheEOSwiththethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethecymbalsthethelawyersthethelawyersthethethelawyersthethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethetheServingman:Rome?MasterServingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Master,MasterServingman:MasterServingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:\n"
     ]
    }
   ],
   "source": [
    "print(generate_based_sequence(1000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
